An extension interface concept for multilayered applications

Extensibility is an important feature of modern software applications. In the context of business applications it is one of the major selection criteria from the customer perspective. Software extensions enable developers to integrate new features to a software system for supporting new requirements. However, there are many open challenges concerning the software provider and the extension developer. A software provider must provide extension interfaces that define the software artifacts of the base application that are allowed to be extended, where and when the extension code will run, and what resources of the base application an extension is allowed to access. While concepts for such interfaces are still a challenging research topic for “traditional” software constructed using a single programming language, they are completely missing for complex systems consisting of several abstraction layers. In addition, state-of-the-art approaches do not support providing different extension interfaces for different stakeholders. To develop an extension for a certain software system, the extension developer has to understand what extension possibilities exist, which software artifacts provide these possibilities, the constraints and dependencies between the extensible software artifacts, and how to correctly implement an extension. For example, a simple user interface extension in a business application can require a developer to consider extensible artifacts from underlying business processes, database tables, and business objects. In commercial applications, extension developers can depend on classical means like application programming interfaces, frameworks, documentation, tutorials, and example code provided by the software provider to understand the extension possibilities and how to successfully implement, deploy, and run an extension. For complex multilayered applications, relying on such classical means can be very hard and time-consuming for the extension developers. In integrated development environments, various program comprehension tools and approaches have helped developers in carrying out development tasks. However, most of the tools focus on the code level, lack the support for multilayered applications, and do not particularly focus on extensibility. In this dissertation I aim to provide better means for defining, implementing, and consuming extension interfaces for multilayered applications. I claim that explicit extension interfaces are vii Abstract (English/Deutsch)English/Deutsch) required for multilayered applications and they are needed for simplifying the implementation (i.e., the concrete realization) and maintainability of extension interfaces on the side of the software provider as well as the consumption of these interfaces by the extension developers. To support this thesis, I first analyze problems with extension interfaces from the perspectives of both the software provider through an example business application and an analysis of a corpus of software systems. I then analyze the problems with the consumption of extension interfaces (i.e., extension development) through a user study involving extension developers performing extension development tasks for a complex business application. Next, I present XPoints, an approach and a language for the specification of extension possibilities for multilayered applications. I develop an instantiation of XPoints evaluate it against current state-of-the-art works and its usability through a user study. I finally show how XPoints can be applied to simplify the extension development through the implementation of a recommender system for extension possibilities for multilayered applications. The advantages of the recommender system are illustrated through an example as well through a comparison between the current state-of-the-art tools for program comprehension. Topics like extension validation, monitoring, and conflict detection are left for future work.